System Booster/System Booster.iso/Texteditors/GoldED Tools/Pharse Completion/PhraseCompletion.c

C/C++ Source or Header | 1996-09-27 | 18.1 KB | 792 lines

/*
** $PROJECT: GoldED Phrase-Completion API-Client
**
** $VER: PhraseCompletion.c 1.4 (27.04.96)
**
** by
**
** Stefan Ruppert , Windthorststrasse 5 , 65439 Floersheim , GERMANY
**
** (C) Copyright 1996
** All Rights Reserved !
**
** $HISTORY:
**
** 27.04.96 : 001.004 : completion didn't worded, if word was at the beginning of a line (fixed)
** 14.04.96 : 001.003 : now uses WHITESPACES arg to get the word to expand
** 24.02.96 : 001.002 : searches now in the line of the cursor
** 09.02.96 : 001.001 : separated in a own program
**
*/

/*FS*//* --------------------------- version defines ---------------------------- */

/* $STARTDEFINE: "BumpRev defines"*/
#define VERSION  1
#define REVISION 4
#define DATE "27.4.96"
#define VERS "PhraseCompletion 1.4"
#define VSTRING "PhraseCompletion 1.4 (27.4.96)\r\n"
#define VERSTAG "\0$VER: PhraseCompletion 1.4 (27.4.96)"
#define NAME "PhraseCompletion"
#define PROJECTNAME "PhraseCompletion: "

/* $ENDDEFINE:   */
/*FE*/

/*FS*//* ------------------------------- include -------------------------------- */

#define __USE_SYSBASE

#include <string.h>
#include <ctype.h>

#include <exec/types.h>
#include <exec/memory.h>

#include <dos/dos.h>

#include <rexx/errors.h>

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/utility.h>
#include <proto/rexxsyslib.h>

#include <clib/alib_protos.h>
#include <clib/alib_stdio_protos.h>

#include "golded:api/include/golded.h"

#include "debug.h"
#include "register.h"
/*FE*/

/*FS*//* ------------------------------- AutoDoc -------------------------------- */

/*GB*** GoldED-API/PharseCompletion ******************************************

     $VER: PharseCompletion.doc 1.4 (27.4.96)

     NAME
          PhraseCompletion

     VERSION
          1.4

     DESCRIPTION
          Just run GoldED and load this as an API-Client ! Then you have the
          following new ARexx command :

     TEMPLATE
          PHRASECOMPLETION WHITESPACES,MAX/N,CASE/S,BACKWARD/S,ALL/S

     FORMAT
          PHRASECOMPLETION [[WHITESPACES] whitespace-characters] [[MAX] number]
                                 [CASE] [BACKWARD] [ALL]

     DESCRIPTION
          The PHRASECOMPLETION ARexx command provides you a new phrase
          completion method. It extracts the actual word-phrase (before cursor)
          and tries to complete this phrase. This is done by searching in the
          buffers for a word beginning with this extracted phrase. The first
          found is displayed in the buffer. If there are more than one words
          matching the phrase, you can step through all found words by just
          using this command again with same cursor position. If the last word
          is reached a ERROR_NO_MORE_ENTRIES error code is returned and then it
          starts again with the first word.

     INPUTS
          WHITESPACES -- a string, which represent the characters to use as
                whitespaces. Default is " \t".

          MAX -- maximal number of matching words. Default is ~0.

          CASE -- don't ignore case-sensetive. Default is ignore.

          BACKWARD -- normaly the buffer is first searched from the actual
                line to the beginnig and then from actual line to the end of
                the buffer. This argument swaps the search direction.

          ALL -- searchs in all opened buffers

     RESULTS
          the command returns RC_OK, if it could complete the pharse. RC_WARN
          if not !

     SPECIAL REQUIREMENTS
          Needs GoldED 3.x to run.

     AVAILABILITY
          ftp://wuarchive.wustl.edu/pub/aminet/text/edit/GED-PhrCmp1.4.lha
          And all other Aminet sites

     AUTHOR
          Stefan Ruppert
          Windthorststrasse 5
          65439 Floersheim
          Germany

          Internet:
          [e-mail]
          [e-mail]
          http://www.uni-mainz.de/~ruppert

     SEE ALSO
          Emacs, GoldED/API

*****************************************************************************/
/*FE*/

/*FS*//* ------------------------------- defines -------------------------------- */

#define PUDDLE_SIZE              4096
#define BUFFER_LEN               512

#define PHRASECOMP_ARGS          "WHITESPACES,MAX/N,CASE/S,BACKWARD/S,ALL/S"

#define MAX_PARAMETER            6

#define EOS                      '\0'

#define USETAG(tag,check)        ((check) ? (tag) : TAG_IGNORE)

/*FE*/

/*FS*//* ----------------------------- structures ------------------------------- */

struct RexxCommands
{
    STRPTR rxc_Command;
    LONG (*rxc_Handler) (struct GlobalData *,struct APIMessage *);
    STRPTR rxc_Template;
};

struct GlobalData
{
    struct Library *gd_SysBase;
    struct Library *gd_DOSBase;
    struct Library *gd_UtilityBase;
    struct Library *gd_RexxSysBase;

    APTR gd_Pool;
    APTR gd_FoundPool;

    struct MsgPort *gd_ApiPort;
    struct MsgPort *gd_RexxPort;

    STRPTR gd_GoldEDHost;

    ULONG gd_Result;
    LONG gd_Found;

    struct List gd_FoundList;
    struct Node *gd_LastFound;

    ULONG gd_Para[MAX_PARAMETER];

    ULONG gd_Len;
    ULONG gd_Max;
    UBYTE gd_Buffer[BUFFER_LEN];
    UBYTE gd_Name[BUFFER_LEN];
    UBYTE gd_LastName[BUFFER_LEN];

    struct APIModifyRequest gd_Modify;
};
/*FE*/

/*FS*//* ------------------------------ prototypes ------------------------------ */

void search_command(struct GlobalData *gd,struct APIMessage *msg);

LONG RexxCmd_PhraseComp(struct GlobalData *gd,struct APIMessage *msg);

BOOL send_rexxcommand(struct GlobalData *gd,STRPTR cmd);
BOOL alloc_name(struct GlobalData *gd,STRPTR name,LONG len);

RegCall void *AsmCreatePool(REGD0 ULONG ,REGD1 ULONG ,REGD2 ULONG ,REGA6 struct Library *);
RegCall void AsmDeletePool(REGA0 APTR ,REGA6 struct Library *);
RegCall void *AsmAllocPooled(REGA0 APTR ,REGD0 ULONG ,REGA6 struct Library *);
RegCall void AsmFreePooled(REGA0 APTR ,REGA1 APTR ,REGD0 ULONG ,REGA6 struct Library *);

/*FE*/

/*FS*//* -------------------------- static data items --------------------------- */

static const STRPTR version = VERSTAG;
static const STRPTR prgname = NAME;

static struct RexxCommands rexxcmd[] = {
    {"PHRASECOMPLETION",RexxCmd_PhraseComp,PHRASECOMP_ARGS},
    {NULL}};

static struct TagItem apitags[] = {
    {API_Client_Name       ,(ULONG) NAME},
    {API_Client_Copyright  ,(ULONG) "©1996 Stefan Ruppert"},
    {API_Client_Purpose    ,(ULONG) VERS "\n\nPhrase completion\nthrough all buffers"},
    {API_Client_Template   ,(ULONG) "PHRASECOMPLETION " PHRASECOMP_ARGS},
    {TAG_DONE,0}};
/*FE*/

/*FS*//* ------------------------- template definition -------------------------- */

#define template    "HOST/K/A"

enum {
    ARG_HOST,
    ARG_MAX};
/*FE*/

/* --------------------------- main entry point --------------------------- */

/*FS*/GetA4 int main(void)
{
    struct Library *SysBase = *((struct Library **) 4L);
    struct Library *DOSBase;
    struct RDArgs *args;
    LONG para[ARG_MAX];
    STRPTR obj = prgname;
    LONG rc = RETURN_OK;

    LONG i;

    /* clear args buffer */
    for(i = 0 ; i < ARG_MAX ; i++)
        para[i] = 0;

    if((DOSBase = OpenLibrary("dos.library",37)) != NULL)
    {
        LONG err = 0;

        if((args = ReadArgs(template,para,NULL)) != NULL)
        {
            APTR pool;

            if((pool = AsmCreatePool(MEMF_CLEAR | MEMF_ANY, PUDDLE_SIZE, PUDDLE_SIZE,SysBase)) != NULL)
            {
                struct GlobalData *gd;

                DB(("golded host : %s\n",para[ARG_HOST]));
                if((gd = AsmAllocPooled(pool,sizeof(struct GlobalData),SysBase)) != NULL)
                {
                    gd->gd_Pool = pool;

                    gd->gd_SysBase = SysBase;
                    gd->gd_DOSBase = DOSBase;

                    gd->gd_UtilityBase   = OpenLibrary("utility.library",37);
                    gd->gd_RexxSysBase   = OpenLibrary("rexxsyslib.library",36);

                    NewList(&gd->gd_FoundList);

                    if(gd->gd_UtilityBase != NULL && gd->gd_RexxSysBase != NULL)
                    {
                        if((gd->gd_ApiPort = CreateMsgPort()))
                        {
                            if((gd->gd_RexxPort = CreateMsgPort()))
                            {
                                gd->gd_GoldEDHost   = (STRPTR)   para[ARG_HOST];

                                sprintf(gd->gd_Buffer,"API PORT=%ld CLASS=%ld",
                                                             gd->gd_ApiPort,
                                                             API_CLASS_ROOT | API_CLASS_REXX);

                                if(send_rexxcommand(gd,gd->gd_Buffer) && gd->gd_Result == RC_OK)
                                {
                                    struct APIMessage *apimsg;
                                    struct APIMessage *msg;

                                    BOOL active = TRUE;

                                    DB(("xrefapi active !\n"));

                                    do
                                    {
                                        WaitPort(gd->gd_ApiPort);

                                        while((apimsg = (struct APIMessage *) GetMsg(gd->gd_ApiPort)))
                                        {
                                            for(msg = apimsg ; msg ; msg = msg->api_Next)
                                            {
                                                if(msg->api_State == API_STATE_NOTIFY)
                                                {
                                                    switch(msg->api_Class)
                                                    {
                                                    case API_CLASS_ROOT:
                                                        switch(msg->api_Action)
                                                        {
                                                        case API_ACTION_DIE:
                                                            active = FALSE;
                                                            break;
                                                        case API_ACTION_INTRODUCE:
                                                            msg->api_Data = apitags;
                                                            break;
                                                        }
                                                        break;
                                                    case API_CLASS_REXX:
                                                        switch(msg->api_Action)
                                                        {
                                                        case API_ACTION_COMMAND:
                                                            search_command(gd,msg);
                                                            break;
                                                        default:
                                                            msg->api_Error = API_ERROR_UNKNOWN;
                                                        }
                                                        break;
                                                    default:
                                                        msg->api_Error = API_ERROR_UNKNOWN;
                                                    }
                                                }
                                            }

                                            ReplyMsg((struct Message *) apimsg);
                                        }
                                    } while(active);
                                    SetIoErr(0);
                                }
                                DeleteMsgPort(gd->gd_RexxPort);
                            }
                            DeleteMsgPort(gd->gd_ApiPort);
                        }

                        if(gd->gd_FoundPool != NULL)
                            AsmDeletePool(gd->gd_FoundPool,SysBase);
                    }

                    CloseLibrary(gd->gd_RexxSysBase);
                    CloseLibrary(gd->gd_UtilityBase);
                }

                AsmDeletePool(pool,SysBase);
            }
            FreeArgs(args);
        }

        if(err == 0)
            err = IoErr();

        if(err != 0)
        {
            PrintFault(err,obj);
            rc = RETURN_ERROR;
        }

        CloseLibrary(DOSBase);
    }

    return rc;
}
#define SysBase         gd->gd_SysBase
#define DOSBase         gd->gd_DOSBase
#define UtilityBase     gd->gd_UtilityBase
#define RexxSysBase     gd->gd_RexxSysBase
/*FE*/

/* -------------------------- find rexx command --------------------------- */

/*FS*/ void search_command(struct GlobalData *gd,struct APIMessage *msg)
{
    struct APIRexxNotify *notify = (struct APIRexxNotify *) msg->api_Data;
    struct RexxCommands  *rxcmd  = rexxcmd;
    LONG len;

    notify->arn_RC = RC_WARN;

    while(rxcmd->rxc_Command)
    {
        len = strlen(rxcmd->rxc_Command);

        if(!strncmp(notify->arn_Command,rxcmd->rxc_Command,len))
        {
            struct RDArgs *rdargs;
            struct RDArgs *args;
            LONG i;

            msg->api_State = API_STATE_CONSUMED;

            strncpy(gd->gd_Buffer,¬ify->arn_Command[len],BUFFER_LEN);
            strncat(gd->gd_Buffer,"\n",BUFFER_LEN);

            if(rdargs = (struct RDArgs *) AllocDosObject(DOS_RDARGS,NULL))
            {
                rdargs->RDA_Source.CS_Buffer   = gd->gd_Buffer;
                rdargs->RDA_Source.CS_Length   = strlen(gd->gd_Buffer);

                for(i=0 ; i < MAX_PARAMETER ; i++)
                    gd->gd_Para[i]=0;

                DB(("rdargs at : %lx\n",rdargs));

                if((args = ReadArgs(rxcmd->rxc_Template,(LONG *) gd->gd_Para,rdargs)))
                {
                    DB(("args at %lx\n",args));

                    notify->arn_RC = rxcmd->rxc_Handler(gd,msg);

                    FreeArgs(args);
                }
                FreeDosObject(DOS_RDARGS , rdargs);
            }
        }
        rxcmd++;
    }

    if(notify->arn_RC != RC_OK)
    {
        Fault(IoErr(),NAME,gd->gd_Buffer,BUFFER_LEN);
        notify->arn_CommandError = gd->gd_Buffer;
    }
}
/*FE*/

/* ---------------------------- rexx commands ----------------------------- */

/*FS*//*"LONG RexxCmd_PhraseComp(struct GlobalData *gd,struct APIMessage *msg)"*/
struct IntArgs
{
    STRPTR ia_WhiteSpaces;
    LONG *ia_Max;
    LONG ia_Case;
    LONG ia_Backward;
    LONG ia_All;
};
/*FS*/ void match_expand(struct GlobalData *gd,struct IntArgs *args,struct LineNode *ln)
{
    STRPTR name;
    STRPTR ptr;
    STRPTR end;
    LONG len;

    ptr = ln->Text;
    end = ptr + ln->Len;

    if(args->ia_Case)
    {
        do
        {
            while(ptr < end && strchr(args->ia_WhiteSpaces,*ptr) != NULL)
                ptr++;

            name = ptr;
            while(ptr < end && strchr(args->ia_WhiteSpaces,*ptr) == NULL)
                ptr++;

            len = ptr - name;
            if(len > gd->gd_Len)
            {
                if(!strncmp(name,gd->gd_Buffer,gd->gd_Len))
                {
                    alloc_name(gd,name,len);
                    if(--gd->gd_Max == 0)
                        break;
                }
            }
        } while(ptr < end);
    } else
    {
        do
        {
            while(ptr < end && strchr(args->ia_WhiteSpaces,*ptr) != NULL)
                ptr++;

            name = ptr;
            while(ptr < end && strchr(args->ia_WhiteSpaces,*ptr) == NULL)
                ptr++;

            len = ptr - name;
            if(len > gd->gd_Len)
            {
                if(!Strnicmp(name,gd->gd_Buffer,gd->gd_Len))
                {
                    alloc_name(gd,name,len);
                    if(--gd->gd_Max == 0)
                        break;
                }
            }
        } while(ptr < end);
    }

    if(ln->Fold != NULL)
    {
        struct LineNode *end;
        len = ln->Fold->Lines;
        ln  = ln->Fold->TextNodes;

        end = ln + len;
        while(ln < end && gd->gd_Max > 0)
        {
            match_expand(gd,args,ln++);
        }
    }

    return;
}
/*FE*/

LONG RexxCmd_PhraseComp(struct GlobalData *gd,struct APIMessage *msg)
{
    struct EditConfig *ec = msg->api_Config;
    struct LineNode *ln;
    struct IntArgs *args = (struct IntArgs *) gd->gd_Para;

    UWORD  column;
    STRPTR wrd;
    STRPTR buf;
    LONG retval = RC_WARN;

    gd->gd_Max = ~0;
    if(args->ia_Max != NULL)
        gd->gd_Max = *args->ia_Max;

    column = ec->Column;
    buf    = ec->CurrentBuffer;
    wrd    = gd->gd_Buffer;

    if(column > 0)
    {
        STRPTR found = NULL;
        STRPTR end   = buf + column;
        STRPTR begin = end - 1;
        LONG foundlen;
        LONG len;

        while(begin >= buf && strchr(args->ia_WhiteSpaces,*begin) == NULL)
            begin--;
        begin++;
        column -= (end - begin);

        len = end - begin;

        if(len == 0)
            SetIoErr(ERROR_REQUIRED_ARG_MISSING);
        else
        {
            movmem(begin,wrd,len);
            wrd[len] = 0;
            gd->gd_Len = len;

            DB(("expand : %s\n",wrd));

            if(!IsListEmpty(&gd->gd_FoundList) && gd->gd_LastName[0] != '\0' &&
                !strncmp(gd->gd_LastName,wrd,strlen(gd->gd_LastName)))
            {
                struct Node *node = gd->gd_LastFound;

                DB(("Get Next word : %lx\n",node));
                if(node != NULL)
                {
                    node = node->ln_Succ;
                    if(node->ln_Succ != NULL)
                        gd->gd_LastFound = node;
                    else
                        gd->gd_LastFound = NULL;
                } else
                    gd->gd_LastFound = gd->gd_FoundList.lh_Head;

                if(gd->gd_LastFound != NULL)
                {
                    found    = gd->gd_LastFound->ln_Name;
                    foundlen = strlen(found);
                } else
                    SetIoErr(ERROR_NO_MORE_ENTRIES);
            } else
            {
                LONG try = 2;

                strcpy(gd->gd_LastName,wrd);
                if(gd->gd_FoundPool != NULL)
                    AsmDeletePool(gd->gd_FoundPool,SysBase);
                NewList(&gd->gd_FoundList);
                gd->gd_LastFound = NULL;
                gd->gd_FoundPool = AsmCreatePool(MEMF_ANY | MEMF_CLEAR,PUDDLE_SIZE,PUDDLE_SIZE,SysBase);

                if(args->ia_WhiteSpaces == NULL)
                    args->ia_WhiteSpaces = " \t";

                while(try > 0 && gd->gd_Max > 0)
                {
                    try--;
                    if(args->ia_Backward)
                    {
                        struct LineNode *end = ec->TextNodes + ec->Lines;
                        ln = &ec->TextNodes[ec->Line]+1;
                        while(ln < end && gd->gd_Max > 0)
                            match_expand(gd,args,ln++);
                    } else
                    {
                        ULONG len;

                        ln = &ec->TextNodes[ec->Line];
                        /* cut current line to the cursor pos */
                        len = ln->Len;
                        ln->Len = ec->Column-1;
                        match_expand(gd,args,ln);
                        ln->Len = len;
                        ln--;

                        while(ln >= ec->TextNodes && gd->gd_Max > 0)
                            match_expand(gd,args,ln--);
                    }
                    args->ia_Backward = !args->ia_Backward;
                }

                if(args->ia_All && gd->gd_Max > 0)
                {
                    struct EditConfig *first = ec;

                    while(first->Node.ln_Pred != NULL)
                        first = (struct EditConfig *) first->Node.ln_Pred;

                    first = (struct EditConfig *) first->Node.ln_Succ;

                    while(first->Node.ln_Succ != NULL && gd->gd_Max > 0)
                    {
                        struct LineNode *end = first->TextNodes + first->Lines;
                        DB(("name : %s\n",first->Name));

                        if(first != ec)
                        {
                            ln = first->TextNodes;
                            while(ln < end && gd->gd_Max > 0)
                                match_expand(gd,args,ln++);
                        }

                        first = (struct EditConfig *) first->Node.ln_Succ;
                    }

                }

                if(gd->gd_FoundList.lh_Head->ln_Succ != NULL)
                {
                    struct Node *node = gd->gd_FoundList.lh_Head;

    #if 0
                    if(args->ia_Select)
                        node = select_node(gd,&gd->gd_FoundList,msg->api_Global->F_ScrnName);
    #endif

                    if(node != NULL)
                    {
                        gd->gd_LastFound = node;
                        found = node->ln_Name;
                        foundlen = strlen(found);
                    } else
                      SetIoErr(ERROR_OBJECT_NOT_FOUND);
                } else
                  SetIoErr(ERROR_OBJECT_NOT_FOUND);
            }

            DB(("found = \"%s\" , len : %ld\n",found,foundlen));
            if(found != NULL && foundlen > 0)
            {
                strncpy(gd->gd_LastName,found,foundlen);
                gd->gd_LastName[foundlen] = '\0';

                strncpy(gd->gd_Buffer,ec->CurrentBuffer,column);
                strncpy(&gd->gd_Buffer[column],found,foundlen);
                strcpy(&gd->gd_Buffer[column + foundlen],ec->CurrentBuffer + ec->Column);
                gd->gd_Modify.mr_Next   = NULL;
                gd->gd_Modify.mr_Line   = ec->Line;
                gd->gd_Modify.mr_Column = column + foundlen;
                gd->gd_Modify.mr_Data   = gd->gd_Buffer;
                gd->gd_Modify.mr_Size   = column + foundlen + (ec->CurrentLen - ec->Column);

                msg->api_Modify = &gd->gd_Modify;

                msg->api_Refresh |= API_REFRESH_LINE;

                retval = RC_OK;
            }
        }
    }

    return retval;
}
/*FE*/

/* -------------------------- support functions --------------------------- */

/*FS*/BOOL send_rexxcommand(struct GlobalData *gd,STRPTR cmd)
{
    struct MsgPort *rexxport;

    Forbid();

    if((rexxport = FindPort(gd->gd_GoldEDHost)))
    {
        struct RexxMsg *rxmsg;
        struct RexxMsg *answer;

        if((rxmsg = CreateRexxMsg(gd->gd_RexxPort, NULL, NULL)) != NULL)
        {
            if((rxmsg->rm_Args[0] = CreateArgstring(cmd, strlen(cmd))) != NULL)
            {
                rxmsg->rm_Action = RXCOMM | RXFF_RESULT;

                PutMsg(rexxport, &rxmsg->rm_Node);

                do
                {
                    WaitPort(gd->gd_RexxPort);

                    if((answer = (struct RexxMsg *) GetMsg(gd->gd_RexxPort)))
                         gd->gd_Result = answer->rm_Result1;

                } while (!answer);

                Permit();

                if(answer->rm_Result1 == RC_OK)
                {
                    if(answer->rm_Result2)
                    {
                        if(gd->gd_Buffer)
                             strcpy(gd->gd_Buffer, (char *)answer->rm_Result2);

                        DeleteArgstring((char *)answer->rm_Result2);
                    }
                }

                DeleteArgstring((char *)ARG0(answer));

                DeleteRexxMsg(answer);

                return(TRUE);
            }
        }
    }

    Permit();

    return(FALSE);
}
/*FE*/
/*FS*/ BOOL alloc_name(struct GlobalData *gd,STRPTR name,LONG len)
{
    struct Node *node;
    BOOL rc = FALSE;

    for(node = gd->gd_FoundList.lh_Head ; node->ln_Succ != NULL ; node = node->ln_Succ)
        if(node->ln_Type == len && !strncmp(node->ln_Name,name,len))
            break;

    if(node->ln_Succ == NULL)
        if((node = AsmAllocPooled(gd->gd_FoundPool,sizeof(struct Node) + len + 1,SysBase)) != NULL)
        {
            node->ln_Name = (STRPTR) (node + 1);
            node->ln_Type = len;

            strncpy(node->ln_Name,name,len);

            AddTail(&gd->gd_FoundList,node);

            rc = TRUE;
          DB(("allocated : %s\n",node->ln_Name));
        }


    return rc;
}
/*FE*/